package com.zhentao.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.zhentao.entity.Activity;
import com.zhentao.entity.ActivityRegistration;
import com.zhentao.mapper.ActivityMapper;
import com.zhentao.mapper.ActivityRegistrationMapper;
import com.zhentao.service.ActivityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 活动服务实现类
 */
@Service
public class ActivityServiceImpl implements ActivityService {
    
    @Autowired
    private ActivityMapper activityMapper;
    
    @Autowired
    private ActivityRegistrationMapper activityRegistrationMapper;
    
    /**
     * 获取活动列表
     */
    @Override
    public List<Activity> getActivityList(Integer type, Integer status) {
        QueryWrapper<Activity> queryWrapper = new QueryWrapper<>();
        
        // 按类型筛选
        if (type != null) {
            queryWrapper.eq("type", type);
        }
        
        // 按状态筛选
        if (status != null) {
            queryWrapper.eq("status", status);
        }
        
        // 按开始时间降序排序
        queryWrapper.orderByDesc("start_time");
        
        return activityMapper.selectList(queryWrapper);
    }
    
    /**
     * 获取活动详情
     */
    @Override
    public Activity getActivityDetail(Integer id) {
        return activityMapper.selectById(id);
    }
    
    /**
     * 获取热门活动列表
     */
    @Override
    public List<Activity> getHotActivities(Integer limit) {
        QueryWrapper<Activity> queryWrapper = new QueryWrapper<>();
        
        // 只查询未删除的活动
        queryWrapper.eq("is_deleted", 0);
        
        // 只查询热门活动（is_hot=1）
        queryWrapper.eq("is_hot", 1);
        
        // 只查询未开始或进行中的活动（status=1 或 status=2）
        queryWrapper.in("status", 1, 2);
        
        // 按开始时间降序
        queryWrapper.orderByDesc("start_time");
        
        // 限制数量
        if (limit != null && limit > 0) {
            queryWrapper.last("LIMIT " + limit);
        }
        
        return activityMapper.selectList(queryWrapper);
    }
    
    /**
     * 报名活动
     * 使用事务和乐观锁机制确保数据一致性
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean registerActivity(Integer activityId, Integer userId) {
        // 1. 查询活动详情
        Activity activity = activityMapper.selectById(activityId);
        if (activity == null) {
            throw new RuntimeException("活动不存在");
        }
        
        // 2. 检查活动是否已删除
        if (activity.getIsDeleted() != null && activity.getIsDeleted() == 1) {
            throw new RuntimeException("活动已不存在");
        }
        
        // 3. 检查活动状态（只有未开始和进行中的活动可以报名）
        if (activity.getStatus() != null && activity.getStatus() == 3) {
            throw new RuntimeException("活动已结束，无法报名");
        }
        
        // 4. 检查报名截止时间
        if (activity.getRegistrationEndTime() != null && 
            LocalDateTime.now().isAfter(activity.getRegistrationEndTime())) {
            throw new RuntimeException("报名时间已截止");
        }
        
        // 5. 【新增】检查用户是否已经报名过该活动
        QueryWrapper<ActivityRegistration> registrationQuery = new QueryWrapper<>();
        registrationQuery.eq("activity_id", activityId)
                        .eq("user_id", userId)
                        .eq("status", 1); // 只检查有效报名（状态为1）
        
        Long existingCount = activityRegistrationMapper.selectCount(registrationQuery);
        if (existingCount != null && existingCount > 0) {
            throw new RuntimeException("您已报名该活动，请勿重复报名");
        }
        
        // 6. 检查人数限制
        Integer currentParticipants = activity.getActualParticipants() != null ? 
                                      activity.getActualParticipants() : 0;
        Integer maxParticipants = activity.getMaxParticipants();
        
        if (maxParticipants != null && currentParticipants >= maxParticipants) {
            throw new RuntimeException("当前活动报名人数已达上限，感谢您的关注，敬请期待后续活动～");
        }
        
        // 7. 使用乐观锁更新参与人数（防止并发问题）
        // 只有当实际参与人数仍然小于最大人数时才更新
        UpdateWrapper<Activity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", activityId);
        updateWrapper.eq("actual_participants", currentParticipants); // 乐观锁条件
        if (maxParticipants != null) {
            updateWrapper.lt("actual_participants", maxParticipants); // 确保不超过最大人数
        }
        updateWrapper.setSql("actual_participants = actual_participants + 1");
        
        int updateCount = activityMapper.update(null, updateWrapper);
        
        // 8. 如果更新失败，说明数据已被其他请求修改（可能已满员）
        if (updateCount == 0) {
            // 重新查询确认是否已满员
            Activity latestActivity = activityMapper.selectById(activityId);
            Integer latestParticipants = latestActivity.getActualParticipants() != null ? 
                                         latestActivity.getActualParticipants() : 0;
            if (maxParticipants != null && latestParticipants >= maxParticipants) {
                throw new RuntimeException("当前活动报名人数已达上限，感谢您的关注，敬请期待后续活动～");
            } else {
                throw new RuntimeException("报名失败，请重试");
            }
        }
        
        // 9. 【新增】插入报名记录
        ActivityRegistration registration = new ActivityRegistration();
        registration.setActivityId(activityId);
        registration.setUserId(userId);
        registration.setRegistrationTime(LocalDateTime.now());
        registration.setStatus(1); // 1：已报名
        
        int insertResult = activityRegistrationMapper.insert(registration);
        if (insertResult <= 0) {
            throw new RuntimeException("报名记录创建失败");
        }
        
        return true;
    }
}


